package cn.lysj.framework.common.validate;

import cn.lysj.framework.common.validate.entity.Medusa;
import cn.lysj.framework.common.validate.validate.Validator;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.*;

/**
 * @author ww
 * @description 处理信息的返回
 * @create 2018-08-14 18:03
 **/
public class Message {

    public static String id = null;

    /**
     * @author ww
     * @date 2018-08-16 23:32
     * @Description 没有分组
     * @param object 校验的对象
     */
    public static Medusa getMsg(Object object){
        Class clazz = object.getClass().getSuperclass(); //获取父类的class
        try {
            Field field = clazz.getDeclaredField("id"); //获取父类中的Id
            field.setAccessible(true); //设置忽略访问权限的限制
            Message.id = (String) field.get(object); //存储起来
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return getMessage(object,new Class<?>[0],new HashMap<>());
    }

    /**
     * @author ww
     * @date 2018-08-16 23:31
     * @Description 有分组
     * @param object 校验的对象
     * @param clazz 组别对象的数组
     */
    public static Medusa getMsg(Object object,Class<?>[] clazz){
        return getMessage(object,clazz,new HashMap<>());
    }

    /**
     * @author ww
     * @date 2018-08-20 15:01
     * @Description 忽略掉某些注解
     * @param object 校验的对象
     * @param map 忽略某个参数中某个注解的校验
     */
    public static Medusa getMsg(Object object, Map<String,Set<Class<? extends Annotation>>> map){
        return getMessage(object,new Class<?>[0],map);
    }

    /**
     * @author ww
     * @date 2018-08-20 15:12
     * @param  clazz 分组
     * @param  object 判断的对象
     * @param  map 忽略掉某些注解
     */
    public static Medusa getMessage(Object object, Class<?>[] clazz,Map<String,Set<Class<? extends Annotation>>> map){
        Validator validator = Validator.newInstance(object,map);
        List<Medusa> set = validator.result(); //获取所有的消息对象
        List<Medusa> listYes = new ArrayList<>(); //存放将排序的错误消息对象
        List<Medusa> listNo = new ArrayList<>(); //存放将不排序的错误消息对象
        Message.id = null;
        if(clazz.length == 0){
            return getList(listYes,listNo,set); //没有分组
        }else{
            return getList(listYes,listNo,set,clazz); //有分组
        }
    }

    /**
     * @author ww
     * @date 2018-08-16 23:31
     * @Description 没有分组
     * @param listYes 排序的Medusa对象
     * @param listNo 不排序的Medusa对象
     * @param set 所有Medusa对象
     */
    public static Medusa getList(List<Medusa> listYes,List<Medusa> listNo,List<Medusa> set){
        //进行排序
        isSort(listYes,listNo,set);
        //先判断排序的集合，如果为空，则遍历不排序的集合,如果都没有错误的信息，则返回true
        return getMedusa(listYes,listNo);
    }

    /**
     * @author ww
     * @date 2018-08-16 23:32
     * @Description 分组的方法
     * @param listYes 排序的Medusa对象
     * @param listNo 不排序的Medusa对象
     * @param set 所有Medusa对象
     * @param clazz 组别的数组
     */
    public static Medusa getList(List<Medusa> listYes,List<Medusa> listNo,List<Medusa> set,Class<?>[] clazz){
        //遍历分组的数组
        for(Class clazzs : clazz){
            //遍历所有的消息
            for (Medusa medusa : set) {
                isSort(medusa,clazzs,listYes,listNo);
            }
        }
        //先判断排序的集合，如果为空，则遍历不排序的集合
        return getMedusa(listYes,listNo);
    }
    
    /**
     * @author ww
     * @date 2018-08-22 11:25
     * @Description 过滤掉正确的medusa对象
     * @param listYes 排序的Medusa对象
     * @param listNo 不排序的Medusa对象
     * @param set 所有Medusa对象
     */
    public static void isSort(List<Medusa> listYes,List<Medusa> listNo,List<Medusa> set){
        for (Medusa medusa : set) {
            if(!medusa.isFlag()){   //过滤掉正确的消息对象
                addList(medusa,listYes,listNo);
            }
        }
    }

    /**
     * @author ww
     * @date 2018-08-22 11:32
     * @Description 过滤掉正确的medusa对象，并进行分组
     * @param medusa
     * @param clazzs 组的类型类
     * @param listYes 排序的集合
     * @param listNo 不排序的集合
     */
    public static void isSort(Medusa medusa,Class clazzs,List<Medusa> listYes,List<Medusa> listNo){
        //过滤掉成功的消息
        if(!medusa.isFlag()){
            //遍历失败消息中的分组
            for(Class clazzss : medusa.getGroups()){
                //判断是否是同一个分组
                if(clazzs == clazzss){
                    addList(medusa,listYes,listNo);
                }
            }
        }
    }

    /**
     * @author ww
     * @date 2018-08-22 11:25
     * @Description 判断medusa对象是否可以排序
     * @param listYes 排序的集合
     * @param listNo 不排序的集合
     * @param medusa
     */
    public static void addList(Medusa medusa,List<Medusa> listYes,List<Medusa> listNo){
        //判断sort,将对象存到不同的集合中（true:排序）
        if (medusa.isSort()) {
            listYes.add(medusa);
        } else {
            listNo.add(medusa);
        }
    }

    /**
     * @author ww
     * @date 2018-08-22 11:25
     * @Description 返回一个结果的对象给前台进行提示
     * @param listYes 排序的集合
     * @param listNo 不排序的集合
     */
    public static Medusa getMedusa(List<Medusa> listYes,List<Medusa> listNo){
        if(listYes.size() != 0){
            for(Medusa medusa : listYes){
                return medusa;
            }
        }else{
            for(Medusa medusa : listNo){
                return medusa;
            }
        }
        //如果接收的消息对象都是正确的，则返回true
        return new Medusa(true);
    }

    /**
     * @author ww
     * @date 2018-08-20 17:01
     * @Description 将多个Class文件存到Set集合中
     * @param args 注解对象
     */
    public static Set<Class<? extends Annotation>> getClassSet(Class<? extends Annotation> ...args){
        Set<Class<? extends Annotation>> set = new LinkedHashSet<>();
        for (int i = 0; i < args.length; i++) {
            set.add(args[i]);
        }
        return set;
    }

    /**
     * @author ww
     * @date 2018-08-20 17:03
     * @Description 将一个Set存储到一个Map集合中
     * @param args 注解对象
     */
    public static Map<String ,Set<Class<? extends Annotation>>> getMap(String name,Class<? extends Annotation> ...args){
        Map<String,Set<Class<? extends Annotation>>> map = new HashMap<>();
        map.put(name,getClassSet(args));
        return map;
    }

    /**
     * @author ww
     * @date 2018-08-20 17:03
     * @Description 将多个Set存储到一个Map集合中
     * @param args 注解对象
     */
    public static Map<String ,Set<Class<? extends Annotation>>> getMaps(Map<String ,Set<Class<? extends Annotation>>> ...args){
        Map<String,Set<Class<? extends Annotation>>> map = new HashMap<>();
        for (int i = 0; i < args.length; i++) {
            for(Map.Entry<String ,Set<Class<? extends Annotation>>> entry : args[i].entrySet()){
                map.put(entry.getKey(),entry.getValue());
            }
        }
        return map;
    }

    /**
     * @author ww
     * @date 2018-08-21 14:17
     * @Description 转换成Message.add().add().add()....的格式
     */
    //存放所有要过滤的注解
    public static Map<String ,Set<Class<? extends Annotation>>> maps = new HashMap<>();
    //返回最终的结果
    private Map<String ,Set<Class<? extends Annotation>>> map = new HashMap<>();

    public Map<String, Set<Class<? extends Annotation>>> getMap() {
        maps = new HashMap<>();
        return map;
    }

    private Message(){}

    public Message(String name,Class<? extends Annotation> ...args){
        maps.put(name,getClassSet(args));
        this.map = maps;
    }

    public Message add(String name,Class<? extends Annotation> ...args) {
        return new Message(name,args);
    }

    /*Medusa medusa = Message.getMsg(entity,
            Message.getMaps(Message.getMap("username",Pattern.class,Unique.class),
                    Message.getMap("password",Pattern.class,Unique.class)));
        if(!medusa.isFlag()){
        return new Resp(Resp.PARAM_ERROR, medusa.getMessage());
    }*/
}


